home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / basic / qlib54.zip / GRAPHICS.DOC < prev    next >
Text File  |  1992-04-25  |  62KB  |  1,490 lines
  1.  
  2. ************************ QLIB GRAPHICS ***********************************
  3.  
  4.   QLIB's graphics subroutines were written initially to provide Hercules
  5.   graphics functions without using QB's QBHERC.COM or MSHERC.COM memory-
  6.   resident drivers, and to provide added capabilities.  Most of these
  7.   subroutines now work in additional graphics modes.  QLIB automatically
  8.   configures itself for the graphics mode in use.
  9.  
  10.   Locations on Graphics screens are defined by coordinate pairs such as (x,y).
  11.   X-coordinates are the horizontal dimensions of the screen, and Y-coordinates
  12.   are the vertical coordinates.  X = 0 is the at the left edge of the screen,
  13.   and X = 719 is the right edge of a Hercules screen, while Y = 0 is the top
  14.   edge of the screen and Y = 347 is the bottom (Hercules).  Thus, the
  15.   coordinate (719,0) is the upper right corner of a Hercules screen.  Maximum
  16.   coordinate values for supported modes are shown on the next page.
  17.  
  18.   You may also use your own coordinate system with QLIB graphics, similar
  19.   to using WINDOW with BASIC's graphics functions.  See QWindow at the
  20.   end of this file.
  21.  
  22.  
  23.  
  24.   QLIB graphics modes are:
  25.  
  26.   Mode           Maximum x   Maximum y    Colors    Equipment
  27.  
  28.   HGraph           719          347       2         Hercules
  29.   HGraph           719          347       16        Hercules InColor
  30.   SCREEN 1         319          199       4         CGA, EGA, MCGA, VGA
  31.   SCREEN 2         639          199       2         CGA, EGA, MCGA, VGA
  32.   SCREEN 3 (1)     719          347       2         Hercules
  33.   SCREEN 4         639          399       2         ATT (5)
  34.   SCREEN 7         319          199       16        EGA, VGA
  35.   SCREEN 8         639          199       16        EGA, VGA
  36.   SCREEN 9         639          349       16        EGA, VGA  (2)
  37.   SCREEN 10        639          349       4         EGA, VGA  (3)
  38.   SCREEN 11        639          479       2         MCGA, VGA
  39.   SCREEN 12        639          479       16        VGA
  40.   SCREEN 13        319          199       256       MCGA, VGA
  41.   VESA6A           799          599       16        (4)
  42.   XMode16      up to 799     up to 599    16        Super EGA/VGA
  43.   Super13          319          399       256       VGA
  44.   Super13a         359          479       256       VGA
  45.   SVGA16       up to 1024    up to 768    16        Super VGA
  46.   SVGA256      up to 1024    up to 768    256       Super VGA
  47.  
  48.   (1) Requires MSHERC.COM or QBHERC.COM
  49.   (2) EGA with 128k or more memory
  50.   (3) monochrome monitor only
  51.   (4) VESA6A is supported by many Super VGA cards with multi-frequency
  52.       monitors.  See ScreenMode.
  53.   (5) untested mode. Your feedback, please!
  54.  
  55.  QLIB's 16-color graphics subroutines were developed with a maximum of
  56.  flexibility, so that extended graphics modes could be accomodated with
  57.  ease.  If you are using an extended EGA or VGA card, QLIB's graphics
  58.  subroutines can be used at resolutions of up to 800 x 600 in 16 colors.
  59.  See XMode16 and ScreenMode.
  60.  
  61.  If you have licenced QLIB's assembly-language source code, you may
  62.  want to re-assemble some of the graphics subroutines if you don't need
  63.  or want to support all QLIB graphics modes.  QLIB source code has several
  64.  pre-defined conditional assembly directives which you may use to eliminate
  65.  unnessesary code:
  66.  
  67.      NOCGA      eliminates code for SCREEN 1 and SCREEN 2
  68.      NOINCOLOR  eliminates code for the Hercules InColor card
  69.                  (InColor equipment will work with Hercules monochrome
  70.                   code in 2 colors)
  71.      NOHERC     eliminates code for Hercules monochrome and InColor
  72.      NOVGA256   eliminates code for the three 256-color modes
  73.      NOMCGA     eliminates SCREEN 11 code
  74.  
  75.      for example, to use only EGA/VGA 16-color code, re-assemble
  76.      DRAWLINE.ASM like this:
  77.  
  78.      C:\MASM>masm /dnoherc /dnocga /dnovga256 /dnomcga drawline;
  79.  
  80.      this will reduce the size of drawline.obj significantly and will
  81.      speed its operation somewhat.
  82.  
  83.  
  84. The style% parameter used in many QLIB Graphics subroutines follows these
  85. general rules:
  86.  
  87.     style% =  0 XORs the text/pixel/line/whatever with the pre-existing
  88.                 screen: if a pixel (x,y) is XORed to the screen, the pixel
  89.                 will be turned on if previously off, or will be turned off
  90.                 if previously on;
  91.  
  92.     style% =  1 is normal; lines are drawn, pixels are turned on, text is
  93.                 foreground-on-background, and the previous screen content
  94.                 is ignored or obliterated;
  95.  
  96.     style% =  2 similar to style% 1, but foreground color only is updated
  97.  
  98.     style% =  3 ORs the line or block with the existing screen; this means
  99.                 that the new stuff is added to the old.
  100.  
  101.     style% =  4 ANDs a block (or fillbox) with the existing screen; within
  102.                 the block's limits, only those pixels where both the
  103.                 previous screen and the pattern in the block have ON pixels
  104.                 will there be a resulting ON pixel;
  105.  
  106.     style% = -3 similar to style% 3, but reverses the foreground and
  107.                 background before combining it with the screen
  108.  
  109.     style% = -2 similar to style% 2, but reverses the foreground and
  110.                 background before combining it with the screen
  111.  
  112.     style% = -1 like style% 1, but uses background color.  In monochrome
  113.                 modes, pixels are erased, text is black with a bright
  114.                 background.
  115.  
  116.  
  117.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  118.  
  119.     Subroutine: BitBlockSave(seg%, x0%, y0%, x1%, y1%)
  120.     Subroutine: BitBlockRestore(seg%, x%, y%, style%)
  121.     object files: bitblock.obj (q$graph.obj)
  122.  
  123.     Function: bytes% = BitBlockBytes(x0%, y0%, x1%, y1%)
  124.     object files: bbbytes.obj (q$graph.obj)
  125.  
  126.     Modes supported: HGraph (mono and InColor)
  127.                      SCREEN 1,2,3,7,8,12,13
  128.                      SCREEN 9,10 (requires 128k+ EGA memory)
  129.                      VESA6A, XMode16, Super13, Super13a
  130.  
  131.     BitBlockSave copies a section of the graphics screen to system memory
  132.     in order to copy the block back to the screen later with BitBlockRestore.
  133.  
  134.     BitBlockBytes returns the number of bytes of memory required store
  135.     the entire pixel block.  Bytes% = 0 if the block is too big.  After
  136.     calculating the bytes required, you may use AllocMem(bytes) to
  137.     allocate the memory space required.  See AllocMem in DATA.DOC.
  138.     Note that bit block memory requirements can be large; the huge model
  139.     library QLIBH.LIB is required for large bitblocks in 16-color modes.
  140.  
  141.     style% values supported by BitBlockRestore are:
  142.  
  143.     SCREEN 13, super13, super13a:
  144.      1 = replace existing screen area with bit block
  145.  
  146.     HGraph (InColor):
  147.      4 = AND the bit block with the existing screen
  148.      3 = OR the bit block with the existing screen
  149.      1,2 = replace existing screen area with bit block
  150.      0 = XOR the bit block with the existing image
  151.     -1,-2 = replace existing screen area with inverse bit block
  152.  
  153.      16-color EGA/VGA-type modes and SCREEN 10:
  154.       same as InColor, plus:
  155.      -3 = OR the inverse bit block with the existing screen
  156.      -4 = AND the inverse bit block with the existing screen
  157.  
  158.      SCREEN 1, 2, 3, 11, and HGraph (mono):
  159.       2 = combine non-zero pixels in the bit block with the
  160.           pre-existing image
  161.       1 = replace the existing screen image with un-altered
  162.           bit block
  163.       0 = XOR the bit block with the existing image
  164.      -1 = replace existing screen image with inverse bit block
  165.      -2 = combine non-zero pixel in the inverse bit block with
  166.           the previous screen image
  167.  
  168.     See example on next page.
  169.  
  170.     BIT BLOCK EXAMPLE:
  171.  
  172.  
  173.         REM  This example calculates the array size required,
  174.         REM  dimensions the array, saves a portion of the screen and
  175.         REM  restores it later.
  176.  
  177.         REM $INCLUDE: 'qlib.bi'
  178.         REM  start in the desired graphics mode
  179.               .
  180.               .
  181.               .
  182.         x0 = 100: y0 = 0: x1 = 400: y1 = 347
  183.         bytes% = BitBlockBytes(x0%, y0%, x1%, y1%)
  184.         REM  Note that BitBlockBytes returns a LONG integer when
  185.         REM  assembled with the .MODEL HUGE directive
  186.         bbseg% = AllocMem(bytes%)
  187.         CALL BitBlockSave(bbseg%, x0%, y0%, x1%, y1%)
  188.               .
  189.               .
  190.               .
  191.         REM  now we'll copy the block back to the screen
  192.         CALL BitBlockRestore(bbseg%, x2%, y2%, style%)
  193.         REM  x2% and y2% may be any coordinates on the screen
  194.         REM  also release the memory block
  195.         CALL FreeMem(bbseg%)
  196.  
  197.  
  198.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  199.  
  200.     Subroutine: BitPlaneSave(seg%, x0%, y0%, x1%, y1%, plane%)
  201.     Subroutine: BitPlaneRestore(seg%, x0%, y0%, style%, plane%)
  202.     object files: bitblock.obj (q$graph.obj)
  203.  
  204.     Function: bytes% = BitPlaneBytes(x0%, y0%, x1%, y1%)
  205.     object files: bbbytes.obj (q$graph.obj)
  206.  
  207.     Modes supported: HGraph (InColor)
  208.                      SCREEN 7,8,12
  209.                      SCREEN 9  (requires 128k+ EGA memory)
  210.                      VESA6A, XMode16
  211.                      SCREEN 10 (planes 0 and 2)
  212.  
  213.     BitPlaneSave subroutines copy a section of the graphics screen to a
  214.     memory buffer in order to copy that block back to the screen with
  215.     BitPlaneRestore.  This is similar to the BitBlockSave/BitBlockRestore
  216.     subroutines, except that BitPlane subroutines copy to or from only one
  217.     of the four "planes" of memory in 16-color modes.  This is handy when
  218.     the area you want to copy is too big to fit in one array, or when you
  219.     want to move or modify only one plane at a time.  The exact color
  220.     represented by each plane is determined by PALETTE or COLOR statements.
  221.  
  222.     BitPlaneBytes calculates the number of bytes of memory required to save
  223.     the desired portion of the plane.  All style% values work with
  224.     BitPlaneRestore.  You may use AllocMem(bytes%) to allocate memory
  225.     space for the bit plane.
  226.  
  227.     Example:
  228.          REM $INCLUDE: 'qlib.bi'
  229.          REM  calculate the array size required, allocate the memory,
  230.          REM  save a portion of one plane of the screen and restores it later.
  231.          REM  note that valid plane numbers are 0 - 3
  232.  
  233.          REM  First I need to establish graphics mode
  234.          CALL Xmode16(xmode%, maxX%, maxY%)
  235.               .
  236.               .
  237.          x0 = 100: y0 = 0: x1 = 400: y1 = 347
  238.          bytes% = BitPlaneBytes(x0%, y0%, x1%, y1%)
  239.          seg% = AllocMem(bytes%): plane% = 0
  240.          CALL BitPlaneSave(seg%, x0%, y0%, x1%, y1%, plane%)
  241.               .
  242.               .
  243.          REM  now we'll copy the plane back to the screen
  244.          CALL BitPlaneRestore(seg%, x2%, y2%, style%, plane%)
  245.  
  246.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  247.  
  248.     Subroutine: ClearView
  249.     object files: drawline.obj (q$graph.obj)
  250.  
  251.     Modes supported: HGraph (mono and InColor)
  252.                      VESA6A, XMode16
  253.                      Super13, Super13a
  254.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  255.  
  256.        ClearView erases everything within the active viewport.  In
  257.     color modes, the background color set by GraphColor is used.  Use
  258.     SetView to establish the active viewport.
  259.  
  260.     Example:
  261.       CALL ClearView
  262.  
  263.  
  264.  
  265.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  266.  
  267.     Subroutine: DrawBox(x0%, y0%, x1%. y1%, style%)
  268.     object file: drawline.obj (q$graph.obj)
  269.  
  270.     Modes supported: HGraph (mono and InColor)
  271.                      VESA6A, XMode16
  272.                      Super13, Super13a
  273.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  274.  
  275.          DrawBox draws a box with corners at (x0%, y0%), (x0%, y1%),
  276.     (x1%, y0%), (x1%, y1%).  Legal style% parameters are -1, 0, and 1.
  277.     If any part of the box lies outside the active graphics viewport,
  278.     that part of the box will not be drawn.  See also LinePattern.
  279.  
  280.     Example:
  281.          CALL HGraph
  282.          x0% = 10: y0% = 10: x1% = 79: y1% = 38: style% = 0
  283.          CALL DrawBox(x0%, y0%, x1%, y1%, style%)
  284.  
  285.  
  286.  
  287.  
  288.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  289.  
  290.     Subroutine: DrawCircle(xc%, yc%, Xradius%, style%)
  291.     Subroutine: CircleAspect(numerator%, denominator%)
  292.     object files: drawcirc.obj (q$graph.obj)
  293.  
  294.     Modes supported: HGraph (mono and InColor)
  295.                      VESA6A, XMode16
  296.                      Super13, Super13a
  297.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  298.  
  299.        DrawCircle draws a circle on a graphics screen centered at xc%, yc%,
  300.     with x-radius Xradius%.  The circle's aspect ratio may be changed with
  301.     CircleAspect.  Legal style% parameters are -1 and 1 with Hercules and
  302.     SCREEN 2.  In color modes, style% parameters 2, -2, 3 and -3 are also
  303.     supported. Only the part of the circle which lies within the viewport
  304.     defined by SetView will be drawn.
  305.  
  306.     CircleAspect changes the aspect ratio of the circle; using CircleAspect,
  307.     you can make the circle look like a flattened ellipse or a tall ellipse.
  308.     CircleAspect changes the Y-dimension of the circle; the X-dimension is
  309.     controlled with Xradius%.  QLIB's default is an aspect ratio of 1:1 in
  310.     most graphics modes.  SCREEN 12 and XMode16 circles may not have a 1:1
  311.     aspect ratio.  CAUTION: extreme aspect ratios are not supported by
  312.     DrawCircle.  With numerator% = 1, a maximum usable denominator% is 5,
  313.     or else a "divide by zero" error will occur.  With denominator% = 1,
  314.     a high numerator will cause unpredictable results.
  315.  
  316.     Example:
  317.          CALL DrawCircle(xc%, yc%, Xradius%, style%)
  318.  
  319.  
  320.  
  321.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  322.  
  323.     Subroutine: DrawLine(x0%, y0%, x1%, y1%, style%)
  324.     object files: drawline.obj (q$graph.obj)
  325.  
  326.     Modes supported: HGraph (mono and InColor)
  327.                      VESA6A, XMode16
  328.                      Super13, Super13a
  329.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  330.  
  331.        DrawLine draws a line from x0%, y0% to x1%, y1%.  Legal style
  332.     parameters are -2, -1, 0, 1 and 2.  See also LinePattern.
  333.  
  334.     Example:
  335.          x0% = 0: y0% = 0: x1% = 719: y1% = 348: style% = -1
  336.          CALL DrawLine(x0%, y0%, x1%, y1%, style%)
  337.          REM this erases a diagonal line across the screen
  338.  
  339.  
  340.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  341.  
  342.    Subroutine: FillArea(x%, y%, reserved%)
  343.    object files: drawline.obj (q$graph.obj)
  344.  
  345.    Modes supported: HGraph (mono and InColor)
  346.                     VESA6A, XMode16
  347.                     Super13, Super13a
  348.                     SCREEN 1,2,3,7,8,9,10,11,12,13
  349.  
  350.          FillArea fills irregularly-shaped areas enclosed by solid lines.
  351.     FillArea works best with SIMPLE areas; holes in the area or areas with
  352.     "inside" corners dividing horizontal lines may not be filled properly.
  353.     Further development is planned, but FillArea in its present form is
  354.     useful in many circumstances.  FillArea works by starting at the seed
  355.     pixel (x%, y%) and looking left and right for non-black region boundaries,
  356.     then filling horizontal lines between the boundaries.  FillArea works
  357.     upward until the top of the area has been reached, then returns to the
  358.     seed pixel and works downward.  Reserved% is reserved for QLIB's style%
  359.     parameter.  FillArea presently assumes style% = 1.
  360.  
  361.     Example:
  362.          CALL HGraph
  363.               .
  364.               .
  365.               .
  366.          CALL GraphColor(attr%)             ' for color modes
  367.          CALL FillPattern(pattern$)         ' optional fill pattern
  368.          CALL FillArea(x%, y%, reserved%)
  369.  
  370.  
  371.  
  372.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  373.  
  374.     Subroutine: FillBox(x0%, y0%, x1%. y1%, style%)
  375.     object files: drawline.obj (q$graph.obj)
  376.  
  377.     Modes supported: HGraph (mono and InColor)
  378.                      VESA6A, XMode16
  379.                      Super13, Super13a
  380.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  381.  
  382.        Similar to DrawBox, FillBox uses the same coordinates and style
  383.     variable, but fills the box instead of drawing the sides.  If
  384.     style% = 1 or 2, an optional pattern may be used to fill the box
  385.     (except SCREEN 1).  See FillPattern.  NOTE: at the present stage of
  386.     development, 16-color modes do not support style% = 1 with a pattern.
  387.  
  388.     Example:
  389.       CALL HGraph
  390.          x0% = 10: y0% = 10: x1% = 79: y1% = 38: style% = 0
  391.          CALL FillBox(x0%, y0%, x1%, y1%, style%)
  392.  
  393.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  394.  
  395.     Subroutine: FillPattern(pattern$)
  396.     object files: fpattern.obj (drawline.obj, q$graph.obj)
  397.  
  398.     Modes supported: HGraph (mono annd InColor)
  399.                      VESA6A, XMode16
  400.                      SCREEN 2,3,7,8,9,10,11,12
  401.  
  402.         FillPattern defines an optional pattern used by FillBox if
  403.     style% >= 1,  or by FillArea (which assumes style% = 1). The bit
  404.     patterns in the first 8 characters of pattern$ are used to modify the
  405.     fill in the box or area.  FillPattern must be called before each call
  406.     to FillBox or FillArea.  See Examples.  FillBox will replace box borders.
  407.     If you want the box to have a solid outline, call DrawBox with style% = 1
  408.     after using FillBox with a pattern.  Using style% = 1, the pattern will
  409.     completely replace whatever was in the box.  16-color modes use
  410.     style% = 2.  BIT2INT in DATA.DOC is useful for establishing patterns.
  411.  
  412.     Sample patterns, and what they produce:
  413.  
  414.     pattern$ = CHR$(255) + STRING$(5,32)    ' produces a pattern of squares
  415.  
  416.     pattern$ = STRING$(8,32)                ' produces vertical lines
  417.  
  418.     pattern$ = CHR$(255) + STRING$(5,0)     ' produces horizontal lines
  419.  
  420.     pattern$ = STRING$(8,0): k% = 1
  421.     FOR i% = 1 TO 8
  422.          MID$(pattern$, i%) = CHR$(k%)
  423.          CALL ShiftINT(k%, 1)
  424.     NEXT i%                                 ' produces diagonal lines, from 
  425.                                             ' upper right to lower left
  426.     pattern$ = STRING$(8,0):k% = 128
  427.     FOR i% = 1 TO 8
  428.          MID$(pattern$, i%) = CHR$(k%)
  429.          CALL ShiftINT(k%, -1)
  430.     NEXT i%                                 ' produces diagonal lines, from
  431.                                             ' upper left to lower right
  432.  
  433.     Example:
  434.       x0% = 10: y0% = 10: x1% = 79: y1% = 38: style% = 1
  435.       pattern$ = CHR$(255) + STRING$(5,32)        ' pattern for squares
  436.       CALL FillPattern(pattern$)
  437.       CALL FillBox(x0%, y0%, x1%, y1%, style%)    ' fill box with pattern
  438.       CALL DrawBox(x0%, y0%, x1%, y1%, style%)    ' draw solid box outline
  439.       CALL FillArea(x%, y%, reserved%)            ' no pattern used
  440.                                                   ' because FillPattern
  441.                                                   ' was not called before
  442.                                                   ' FillArea
  443.  
  444.  
  445.  
  446.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  447.  
  448.     Subroutine: GCopy(frompage%, topage%, oops%)
  449.     object files: gcopy.obj (q$graph.obj, gpage.obj)
  450.  
  451.     Modes supported: HGraph (mono and InColor)
  452.                      Super13
  453.                      SCREEN 3,7,8,9,10
  454.  
  455.         Similar to BASIC's PCOPY command, GCopy copies one page of
  456.     graphics memory to another, but returns an error flag instead of
  457.     requiring ON ERROR to trap errors.  GCopy also works with the Super13
  458.     VGA mode.  oops% = 0 if no error, or -1 if GCopy is not supported or
  459.     if either frompage% or topage% is too large.
  460.  
  461.     Example:
  462.         frompage% = 0: topage% = 1
  463.         CALL GCopy(frompage%, topage%, oops%)
  464.  
  465.  
  466.  
  467.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  468.  
  469.     Subroutine: GetPixel(x%, y%, value%)
  470.     object file: pixel.obj (q$graph.obj, a$rdot.obj)
  471.  
  472.     Modes supported: HGraph (mono and InColor)
  473.                      VESA6A, XMode16
  474.                      Super13, Super13a
  475.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  476.  
  477.          Determines the color of the pixel located at (x%, y%).
  478.     Returns value% = -1 if (x%,y%) falls outside the active graphics
  479.     viewport.
  480.  
  481.     Example:
  482.          x% = 0: y% = 0
  483.          CALL GetPixel(x%, y%, value%)
  484.          REM  This will determine the color of the pixel at the upper left
  485.          REM  corner of the screen.
  486.  
  487.  
  488.  
  489.  
  490.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  491.  
  492.     Subroutine: GraphColor(attr%)
  493.     object file: q$graph.obj
  494.  
  495.     Modes supported: HGraph (InColor)
  496.                      VESA6A, XMode16
  497.                      Super13, Super13a
  498.                      SCREEN 1,7,8,9,10,12,13
  499.  
  500.         Sets the color attribute to be used when QLIB subroutines are
  501.     used in color modes.  Color attributes for 16-color modes may be
  502.     calculated with ColorAttr (See VIDEO.DOC).
  503.  
  504.  
  505.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  506.  
  507.     Subroutine: GCursor(x%, y%)
  508.     Subroutine: GUCursor(x%, y%)
  509.     object file: gcursor.obj (q$graph.obj)
  510.  
  511.     Modes supported: HGraph (mono and InColor)
  512.                      VESA6A, XMode16
  513.                      Super13, Super13a
  514.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  515.  
  516.        GCursor subroutines put a text cursor on graphics screens
  517.     at the character box with upper left coordinates at x%, y%.
  518.     GCursor and GUCursor subroutines are similar to QLIB's text-mode
  519.     CursorON and UCursorON subroutines, except that GCursor waits until
  520.     a key has been pressed before returning to QuickBASIC.  The key
  521.     pressed may be determined with QLIB's input subroutines, or with
  522.     QB's INKEY$ function.  In HGraph, SCREEN 9, 10, or 12, GCursor
  523.     subroutines work with either normal text or QLIB's small text.  To use
  524.     GCursor with text printed by BASIC, see example 2.
  525.  
  526.     Example 1:
  527.          CALL HGraph
  528.          a$ = "I want a cursor at the 'I' at the start of this line"
  529.          x% = 5: y% = 3: style% = 1
  530.          CALL GPrint(a$, x%, y%, style%)
  531.          CALL GCursor(x%, y%)
  532.  
  533.     Example 2:
  534.          SCREEN 3                           ' uses QBHERC.COM or MSHERC.COM
  535.          CALL StdText                       ' make sure the BIOS data area
  536.                                             ' has been updated
  537.          row% = 10: column% = 3
  538.          LOCATE row%, column%: PRINT a$     ' use QB to print text
  539.          x% = (column% - 1) * 9             ' this example is for a
  540.          y% = (row% - 1) * 14               ' QBHERC 9x14 character box
  541.          CALL GCursor(x%, y%)
  542.  
  543.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  544.  
  545.     Subroutine: HGraph
  546.     Subroutine: HGraph0
  547.     object files: hgraph.obj (q$herc.obj, hmode.obj)
  548.  
  549.     Subroutine: HText
  550.     object files: hmode.obj (q$herc.obj)
  551.  
  552.     Requires Hercules (mono or InColor)
  553.  
  554.         These subroutines change modes on the Hercules graphics card,
  555.     without using QBHERC.COM.  If you use HGraph to set graphics mode,
  556.     QuickBASIC video input/output functions will not work, and you must use
  557.     HText to restore text mode.  QB2/QB3/QB87 users MUST use HGraph to use
  558.     Hercules graphics.  HText resets QPage to 0.  (See UseTPage in VIDEO.DOC)
  559.     HGraph clears the entire video buffer; HGraph0 clears only page 0.
  560.  
  561.     With HGraph0, anything in graph page 1 is undisturbed.  A graph may
  562.     be stored in page 1, the system can be switched back to text mode for a
  563.     while, and if text page 8 - 15 are not used, the graph may be restored
  564.     by calling HGraph0 and GCopy(1, 0, oops%).
  565.  
  566.     HGraph0 can also be used if text screens are stored in pages 8 - 15.
  567.     As long as graph page 1 is not used, the text screens will not be
  568.     disturbed and can be restored with HText and TCopy.
  569.  
  570.     If you are using Hercules graphics in a 2-monitor system, use HGraph0.
  571.     HGraph0 and HText will make the Monochrome monitor the default; to
  572.     use the color monitor, call ModeColor (See VIDEO.DOC).
  573.  
  574.     Example:
  575.          CALL HGraph         ' establishes Hercules Graphics mode
  576.                              ' QLIB graphics subroutines will work properly
  577.          CALL HText          ' returns Hercules system to text mode
  578.  
  579.  
  580.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  581.  
  582.     Subroutine: GCenter(st$, y%, style%)
  583.     object files: gcenter.obj (q$graph.obj, gprint.obj, f8x14.obj)
  584.  
  585.     GCenter prints text on a graphics screen, centered horizontally.
  586.     This subroutine calculates the correct x-coordinate, then calls
  587.     GPrint.  GCenter supports all style% parameters and graphics
  588.     modes supported by GPrint.
  589.  
  590.     Example:
  591.         REM  I want to center a graph title at the top of the screen
  592.         y% = 0                   ' top of screen
  593.         style% = 1: title$ = "Graph Title"
  594.         CALL GCenter(title$, y%, style%)
  595.  
  596.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  597.  
  598.     Subroutine: GCenterX(st$, y%, style%)
  599.     object files: gcenterx.obj (q$graph.obj, gprintx.obj, f8x14.obj)
  600.  
  601.     GCenterX prints double-width text on a graphics screen, centered
  602.     horizontally.  This subroutine calculates the correct x-coordinate,
  603.     then calls GPrintX.  GCenterX supports all style% parameters and
  604.     graphics modes supported by GPrintX.
  605.  
  606.     Example:
  607.         REM  I want to center a graph title at the top of the screen
  608.         y% = 0                   ' top of screen
  609.         style% = 1
  610.         title$ = "Graph Title"
  611.         CALL GCenterX(title$, y%, style%)
  612.  
  613.  
  614.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  615.  
  616.     Subroutine: GLineEdit(st$, x%, y%, style%, options%, keycode%)
  617.     object files: gedit.obj (gcursor.obj, gprint.obj, lineedit.obj)
  618.  
  619.     Modes supported: HGraph (mono and InColor)
  620.                      VESA6A, XMode16, Super13, Super13a
  621.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  622.  
  623.       GLineEdit works like LineEdit (see INPUT.DOC), but is usable in
  624.     graphics modes.  GLineEdit uses all LineEdit options except 8 (BIOS
  625.     display) and -32768 (alternate cursor).  All LineEdit editing commands,
  626.     as well as StartEdit and LastEdit, work properly with GLineEdit.
  627.     GLineEdit also works fine with SmallText.  See LineEdit for examples.
  628.     Style% 1 and -1 work best.
  629.  
  630.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  631.  
  632.     Subroutine: GLoad(filename$, oops%)
  633.     Subroutine: GSave(filename$, oops%)
  634.     object files: gsave.obj (q$graph.obj)
  635.  
  636.     Modes supported: HGraph (mono and InColor)
  637.                      VESA6A, XMode16
  638.                      Super13, Super13a
  639.                      SCREEN 1,2,3,7,8,12,13
  640.                      SCREEN 9,10 (requires 128k+ EGA memory)
  641.  
  642.        GLoad loads a Graphics screen from a file to the screen.  The file
  643.     must have been previously saved by GSave.  GLoad and GSave load to or
  644.     save from the active graphics page.  Filename$ must be a ASCIIZ
  645.     (zero-terminated) string.  See example.  If no error occurred, oops% = 0.
  646.     Oops% will be an MS-DOS error code if a file handling error occurs.
  647.     See the introductory remarks in DISK.DOC for MS-DOS error codes.
  648.  
  649.     NOTE: files created by GSave eat lots of disk space:
  650.  
  651.          HGraph  (mono)      32,768 bytes
  652.          HGraph  (InColor)  131,072 bytes
  653.          Super13            128,000 bytes
  654.          Super13a           172,800 bytes
  655.          VESA6A             240,000 bytes
  656.          XMode16      up to 240,000 bytes
  657.          SCREEN 1            16,384 bytes
  658.          SCREEN 2            16,384 bytes
  659.          SCREEN 7            32,000 bytes
  660.          SCREEN 8            64,000 bytes
  661.          SCREEN 9           112,000 bytes
  662.          SCREEN 10           56,000 bytes
  663.          SCREEN 11           38,400 bytes
  664.          SCREEN 12          153,600 bytes
  665.          SCREEN 13           64,000 bytes
  666.  
  667.     Example:
  668.         filename$ = "BARGRAPH.HGC" + CHR$(0)
  669.         CALL GSave(filename$, oops%)
  670.  
  671.  
  672.  
  673.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  674.  
  675.     Subroutine: GPage(page%, oops%)
  676.     object files: gpage.obj (q$graph.obj, q$herc.obj, egainfo.obj)
  677.  
  678.     Modes supported: HGraph (mono and InColor)
  679.                      Super13
  680.                      SCREEN 7,8
  681.                      SCREEN 9,10    (256k EGA memory)
  682.  
  683.         GPage combines the function of UseGPage and ShowGPage; see UseGPage
  684.     and ShowGPage for further information.
  685.  
  686.     Example:
  687.         CALL GPage(page%, oops%)
  688.         REM this is equivalent to
  689.         REM  CALL UseGPage(page%, oops%)
  690.         REM  CALL ShowGPage(page%, oops%)
  691.  
  692.  
  693.  
  694.  
  695.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  696.  
  697.     Subroutine: GPrint(st$, x%, y%, style%)
  698.     object files: gprint.obj (q$graph.bj, f8x14.obj)
  699.  
  700.     Modes supported: HGraph (mono amd InColor)
  701.                      VESA6A, XMode16
  702.                      Super13, Super13a
  703.                      SCREEN 1  (style% 1 and -1 only)
  704.                      SCREEN 2,3,7,8,9,10,11,12,13
  705.  
  706.     GPrint offers much more flexibility than BASIC's PRINT command when
  707.     printing text on a graphics screen, and it's the only way to put text
  708.     on a Hercules graphics screen if MSHERC is not loaded.  GPrint prints
  709.     a string of text anywhere on the screen in normal, reverse video, XOR
  710.     or "foreground only" modes.  GPrint is also much faster than QB's PRINT
  711.     command in graphics modes.
  712.  
  713.     The size of each character and the number of characters across the
  714.     screen depends on the current graphics mode:
  715.  
  716.     mode              standard character size    columns
  717.  
  718.     HGraph & SCREEN 3    8 x 14                    90
  719.     SCREEN 1             8 x 8                     40
  720.     SCREEN 2             8 x 8                     80
  721.     SCREEN 7             8 x 8                     40
  722.     SCREEN 8             8 x 8                     80
  723.     SCREEN 9,10,11,12    8 x 14                    80
  724.     SCREEN 13            8 x 8                     40
  725.     Super13              8 x 14                    40
  726.     Super13a             8 x 14                    45
  727.     VESA6A               8 x 14                   100
  728.     XMode16              8 x 14                  varies
  729.  
  730.     All ASCII characters may be used.  x% and y% are the PIXEL locations of
  731.     the upper left corner of the first character.  SmallText, below, allows
  732.     GPrint to use the smaller 8 x 8 character in Hercules, VESA6A, XMode16
  733.     and SCREEN 9-12 modes.  Legal style% values are -1, 0, 1 and 2.
  734.     16-color modes also allow style% = -2, which is like style% 2 except
  735.     that the text background only is printed.
  736.  
  737.     In modes with 8 x 8 characters, you must call SmallText sometime
  738.     before calling GPrint if you use characters greater than CHR$(127).
  739.  
  740.     To calculate how many rows of text a graphics screen can display,
  741.     divide maximum Y by pixel rows (i.e., a Hercules screen can display
  742.     347/8 = 43 rows of text in SmallText mode).
  743.  
  744.     Example:
  745.       st$ = "This is an example of text in graphics mode"
  746.       x% = 10: y% = 20: CALL GPrint(st$, x%, y%, style%)
  747.  
  748.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  749.  
  750.     Subroutine: GPrintDOWN(st$, x%, y%, style%)
  751.     Subroutine: GPrintUP(st$, x%, y%, style%)
  752.     object files: gprint.obj (q$graph.obj, f8x14.obj)
  753.  
  754.     Modes supported: same as GPrint
  755.  
  756.     GPrintUP rotates the string so that text reads from the bottom of
  757.     the screen to the top.  This is useful for labeling the vertical axis of
  758.     a graph, among other things.  GPrintDOWN reads from the top of the
  759.     screen to the bottom.  These subroutines use SmallText's 8 x 8 character
  760.     box, allowing up to 43 characters from the bottom of the screen to the
  761.     top in Hercules mode.  If you are going to use characters greater than
  762.     CHR$(127), you must call SmallText some time in your program before
  763.     calling GPrintDOWN/UP.  However, QLIB does not need to be in SmallText
  764.     mode when you call GPrintDOWN or GPrintUP.    All GPrint style% values are
  765.     valid.
  766.  
  767.     Example:
  768.          DEFINT a - z
  769.          CALL HGraph
  770.          CALL SmallText             ' let GPrintUP know where to find
  771.              .                      ' character definitions > CHR$(127)
  772.              .
  773.              .
  774.          CALL GPrintUP(text$, x%, y%, style%)
  775.  
  776.  
  777.  
  778.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  779.  
  780.     Subroutine: GPrintX(st$, x%, y%, style%)
  781.     Subroutine: GPrint2X(st$, x%, y%, style%)
  782.     Subroutine: GPrintDOWNX(st$, x%, y%, style%)
  783.     Subroutine: GPrintDOWN2X(st$, x%, y%, style%)
  784.     Subroutine: GPrintUPX(st$, x%, y%, style%)
  785.     Subroutine: GPrintUP2X(st$, x%, y%, style%)
  786.     object files: gprintx.obj (q$graph.obj, f8x8.obj)
  787.  
  788.     Modes supported: same as GPrint
  789.  
  790.        GPrintX subroutines are similar to GPrint, GPrintUP and GPrintDOWN,
  791.     except each character in st$ is expanded to twice its normal horizontal
  792.     size before printing it on the screen; this is handy for graph headings.
  793.     GPrint2X subroutines expand each character horizontally and vertically;
  794.     All graphics modes and styles supported by GPrint work fine with these
  795.     expanded character subroutines.  See GPrint for example.
  796.  
  797.  
  798.  
  799.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  800.  
  801.     Subroutine: LinePattern(pattern$)
  802.     object files: fpattern.obj (drawline.obj, q$graph.obj)
  803.  
  804.        LinePattern passes a string of characters of up to 8 bytes to QLIB's
  805.     DrawLine and DrawBox subroutines.  The pattern of bits in pattern$ modify
  806.     lines so that they are drawn as a series of dots and/or dashes instead of
  807.     as a solid line.  Lines drawn with a pattern will be slower than those
  808.     drawn without a pattern.  In order to use pattern$, style% must be greater
  809.     than zero. On monochrome screens, only style% 1 and 2 are useful.
  810.     LinePattern must be called before each call to DrawLine or DrawBox if
  811.     it is to work.
  812.  
  813.     Modes supported: HGraph (mono and InColor)
  814.                      VESA6A, XMode16
  815.                      Super13, Super13a
  816.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  817.  
  818.      Style% parameters have the following effects:
  819.  
  820.           style% 1 = both foreground and background colors are
  821.                   drawn, obliterating underlying pixels
  822.           style% 2 = foreground only replaces pre-existing pixels.
  823.           style% 3 = foreground is ORed with pre-existing pixels
  824.           style% 4 = foreground is ANDed with pre-existing pixels.
  825.  
  826.     Example:
  827.      pattern$ = SPACE$(8)
  828.      CALL LinePattern(pattern$)
  829.      CALL DrawBox(x0, y0, x1, y1, style%)
  830.  
  831.  
  832.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  833.  
  834.     Function: MakeGVScreen
  835.     Subroutine: KillGVScreen
  836.     object files: gvscreen.obj (q$graph.obj, q$alloc.obj)
  837.  
  838.          MakeGVScreen permits Hercules graphics subroutines to be directed
  839.     to virtual screens.  This is similar to QLIB's text-mode VScreens.
  840.     Hercules virtual screens may be used with ANY computer, whether a
  841.     Hercules Graphics Card is installed or not.  After the graph has been
  842.     created in memory it can be printed with ScreenDump or saved with GSave.
  843.  
  844.     Graphics subroutines known to work with virtual screens include:
  845.  
  846.      Gprint        GPrintUP     GPrintDOWN     SmallText   StdText
  847.      DrawLine      DrawCircle   DrawBox        FillBox     FillArea
  848.      CircleAspect  FillPattern  GetPixel       SetPixel    GSave
  849.      GLoad         ScreenDump   GetGBlock      SetGBlock
  850.  
  851.     Example:
  852.         REM $INCLUDE: 'qlib.bi'
  853.         gseg% = MakeGVScreen       ' MakeGVScreen allocates memory for
  854.                                    ' the graph and makes QLIB's graphics
  855.                                    ' subroutines use that memory.  gseg% = 0
  856.                                    ' if insufficient memory is available.
  857.         CALL UseHerc               ' this is nessesary only if the computer
  858.                                    ' is in some other graphics mode
  859.  
  860.         CALL DrawLine(x0%, y0%, x1%, y1%, style%)
  861.              .
  862.              .
  863.              .
  864.         CALL KillGVScreen          ' release the memory and restore QLIB's
  865.                                    ' defaults after all I'm done with the
  866.                                    ' graph.
  867.         CALL UseDefault            ' do this if you called UseHerc
  868.  
  869.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  870.  
  871.     Subroutine: ScreenMode(mode%)
  872.     object files: scrmode.obj (hgraph.obj, hmode.obj)
  873.  
  874.     ScreenMode allows graphics or text mode to be set, bypassing
  875.     QuickBASIC's SCREEN command.  If your program uses QLIB's graphics
  876.     subroutines instead of QuickBASIC's graphics commands, you can reduce
  877.     your program's size significantly by using ScreenMode instead of
  878.     SCREEN.  ScreenMode also allows you to use VESA mode &H6A, which
  879.     is supported by QLIB's graphics.
  880.  
  881.     The mode% parameter is the BIOS mode number for the screen mode
  882.     (except Hercules - QLIB uses the Microsoft convention of mode 8
  883.     for Hercules since no BIOS mode number exists for Hercules).
  884.  
  885.     BIOS mode numbers and the equivalent QuickBASIC SCREEN numbers are:
  886.  
  887.          BIOS number      equipment             SCREEN number
  888.  
  889.            &H3            CGA, MCGA, EGA, VGA   SCREEN 0 (text mode)
  890.  
  891.            &H4            CGA, MCGA, EGA, VGA   SCREEN 1
  892.            &H5            CGA, MCGA, EGA, VGA   SCREEN 1
  893.  
  894.            &H6            CGA, MCGA, EGA, VGA   SCREEN 2
  895.  
  896.            &H7            Monochrome, Hercules  SCREEN 0 (text mode)
  897.                           EGA Monochrome
  898.  
  899.            &H8            Hercules, InColor     SCREEN 3
  900.                                                 (requires MSHERC.COM)
  901.  
  902.            &HD            EGA, VGA              SCREEN 7
  903.  
  904.            &HE            EGA, VGA              SCREEN 8
  905.  
  906.            &HF            EGA, VGA (monochrome) SCREEN 10   128k+ memory
  907.  
  908.            &H10           EGA, VGA              SCREEN 9    128k+ memory
  909.  
  910.            &H11           MCGA, VGA             SCREEN 11
  911.  
  912.            &H12           VGA                   SCREEN 12
  913.  
  914.            &H13           MCGA, VGA             SCREEN 13
  915.  
  916.            &H6A           VESA VGA
  917.  
  918.     NOTE: ScreenMode is NOT intended for switching between a color
  919.     monitor and a monochrome monitor.  Use ModeColor and ModeMono for
  920.     monitor switching.   
  921.  
  922.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  923.  
  924.     Subroutine: SetPixel(x%, y%, style%)
  925.     object files: pixel.obj (q$graph.obj)
  926.  
  927.     Modes supported: HGraph (mono and InColor)
  928.                      VESA6A, XMode16
  929.                      Super13, Super13a
  930.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  931.  
  932.          Sets the pixel at (x%, y%) according to the specified style% and
  933.     current GraphColor.  Legal style% values are -1, 0, and 1.  Style% 2,
  934.     3, -2 and -3 are supported in 16-color modes.  Coordinates outside the
  935.     active graphics viewport are ignored.
  936.  
  937.     Example:
  938.          x% = 10: y% = 10: style% = 0
  939.          CALL SetPixel(x%, y%, style%)
  940.          REM  In this example, the pixel will be turned off if it had been
  941.          REM  on, and will be turned on if it had been off.
  942.  
  943.  
  944.  
  945.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  946.  
  947.     Subroutine: ScreenDump(oops%)
  948.     object files: scrndump.obj (q$graph.obj)
  949.  
  950.     Modes supported: HGraph (mono) not yet tested with InColor
  951.                      SCREEN 3
  952.  
  953.          Prints the active graphics screen on a graphics printer (Epson MX,
  954.     FX, RX; IBM Graphics Printer, IBM ProPrinter, and compatibles).
  955.     ScreenDump can be stopped with the ESC key.  If this occurs, oops% = 27
  956.     is returned (27 is the ASCII character code for the ESC key).  If the
  957.     computer is not in Hercules graphics mode, oops% = -1.  If all went
  958.     well, oops% = 0.  Use PrinterReady (EQUIP.DOC) to see if the printer is
  959.     ready.
  960.  
  961.     Example:
  962.          CALL ScreenDump(oops%)
  963.          oops$ = ""
  964.          IF oops% = -1 THEN oops$ = "Not Hercules mode"
  965.          IF oops% = 27 THEN oops$ = "Printing stopped"
  966.          IF LEN(oops$) THEN PRINT oops$
  967.  
  968.  
  969.  
  970.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  971.  
  972.     Subroutine: ShowGPage(gpage%, oops%)
  973.     object files: gpage.obj (q$graph.obj, egainfo.obj)
  974.  
  975.     Modes supported: HGraph (mono and InColor) pages 0 and 1
  976.                             (must be default mode)
  977.                      SCREEN 3      pages 0 and 1
  978.                      SCREEN 7      pages 0 through 7  (depends on EGA memory)
  979.                      SCREEN 8      pages 0 through 3  (depends on EGA memory)
  980.                      SCREEN 9      pages 0 and 1      (256k EGA memory)
  981.                      SCREEN 10     pages 0 and 1      (256k EGA memory)
  982.                      Super13       pages 0 and 1
  983.  
  984.          ShowGPage changes the graph page visible on the screen.
  985.     This can be handy for animation or for storing one graph while another
  986.     is displayed.  If gpage% is too large for the default mode, oops% = -1.
  987.     See also GPage.
  988.  
  989.     Example:
  990.          CALL HGraph              ' establish Hercules graphics mode
  991.               .                   ' HGraph calls Use64k
  992.               .
  993.               .                   ' display graph 0
  994.               .
  995.          gpage% = 1
  996.          CALL UseGPage(gpage%, oops%)
  997.                                   ' now put a graph in the second page
  998.               .
  999.               .
  1000.               .
  1001.          CALL ShowGPage(gpage%, oops%)
  1002.                                   ' let's look at graph 1 now that it's 
  1003.               .                   ' complete
  1004.               .
  1005.               .
  1006.          gpage% = 0
  1007.          CALL GPage(gpage%, oops%) ' restore default output page
  1008.                                    ' and look at graph 0
  1009.  
  1010.  
  1011.  
  1012.  
  1013.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1014.  
  1015.     Subroutine: ShowGraphPlane(plane%, oops)
  1016.     object files: gplane.obj (q$graph.obj)
  1017.  
  1018.     Modes supported: VESA6A, XMode16
  1019.                      SCREEN 7,8,12
  1020.                      SCREEN 9  (128k or more EGA memory)
  1021.                      SCREEN 10 (planes 0 and 2, 128k or more EGA memory)
  1022.  
  1023.         EGA and VGA memory in 16-color modes is arranged in 4 parallel
  1024.     "planes".  The 16 colors available when all planes are visible result
  1025.     from a combination of the data bits in each plane at each data address.
  1026.     The planes, numbered 0, 1, 2 and 3, each control a single color.  With
  1027.     the default palette, plane 0 is blue, plane 1 is green, plane 2 is red
  1028.     and plane 3 is "intensity".  A pixel that appears bright blue in the
  1029.     screen represents pixels at identical locations in the Blue and Intensity
  1030.     planes.  (Note that the actual colors each plane represents may change
  1031.     depending on the use of QuickBASIC's COLOR and PALETTE statements).
  1032.  
  1033.     The plane% parameters are:
  1034.  
  1035.     plane 0    plane% = 1
  1036.     plane 1    plane% = 2
  1037.     plane 2    plane% = 4
  1038.     plane 3    plane% = 8
  1039.  
  1040.     Use BASIC's OR operator to show more than one plane; i.e., to
  1041.     show only planes 0 and 3, plane% = 1 OR 8.  To restore normal output,
  1042.     plane% = 1 OR 2 OR 4 OR 8.
  1043.  
  1044.     Example:
  1045.         CALL ShowGraphPlane(plane%, oops)
  1046.  
  1047.  
  1048.  
  1049.  
  1050.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1051.  
  1052.     Subroutine: SetView(x0%, y0%, x1%, y1%)
  1053.     Subroutine: GetView(x0%, y0%, x1%, y1%)
  1054.     object files: view.obj (q$graph.obj)
  1055.  
  1056.     Modes supported: HGraph (mono and InColor)
  1057.                      VESA6A, XMode16
  1058.                      Super13, Super13a
  1059.                      SCREEN 1,2,3,7,8,9,10,11,12,13
  1060.  
  1061.          SetView establishes the active viewport on the active graphics
  1062.     page.  Most QLIB graphics subroutines limit their output to the
  1063.     active viewport.  GetView returns the viewport coordinates
  1064.     presently active.  QLIB's default viewport is the entire graphics
  1065.     screen.  If SetView is called with coordinates outside legal bounds
  1066.     (for example, if x1% = 1000), SetView limits the coordinates to the
  1067.     bounds for the active graphics mode (or to Hercules bounds if the
  1068.     system is either not in graphics mode or in an unsupported mode).
  1069.     This is NOT like QuickBASIC, which calls the out-of-bounds coordinate
  1070.     an illegal function call.  This SetView feature is handy for clearing
  1071.     out old view data or for establishing the entire screen as the
  1072.     viewport when the exact limits are variable or unknown (such as
  1073.     with XMode16).
  1074.  
  1075.     Example:
  1076.          CALL SetView(x0%, y0%, x1%, y1%)
  1077.  
  1078.  
  1079.  
  1080.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1081.  
  1082.     Subroutine: SmallText
  1083.     Subroutine: StdText
  1084.     object files: smalltxt.obj (gprint.obj, q$graph.obj, f8x8.obj)
  1085.  
  1086.     Modes supported: HGraph (mono and InColor)
  1087.                      VESA6A, XMode16
  1088.                      SCREEN 3,9,10,12
  1089.  
  1090.     GPrint and GLineEdit may be set to use a smaller 8 x 8 character,
  1091.     which allows up to 43 rows of text in Hercules graphics mode, where
  1092.     StdText (QLIB's default) results in a maximum 25 rows of text.  Once
  1093.     SmallText is called, GPrint and GLineEdit will print 8 x 8 text until
  1094.     the 8 x 14 character is restored with StdText.  8x8 and 8x14 text
  1095.     may be mixed on one screen.
  1096.  
  1097.     Example:
  1098.          CALL HGraph               ' establish Hercules graphics mode
  1099.          CALL SmallText            ' sets GPrint to use small text
  1100.          CALL GPrint(a$, x0%, y0%, style%)
  1101.  
  1102.  
  1103.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1104.  
  1105.     Subroutine: Super13
  1106.     object files: super13.obj (q$graph.obj)
  1107.  
  1108.     Requires VGA
  1109.  
  1110.          This subroutine changes VGA cards to an undocumented 320 x 400
  1111.     256-color mode.  I have used this mode on PS/2 computers, and it should
  1112.     be compatable with most other VGA systems.  This mode has twice the
  1113.     resolution of SCREEN 13, and QLIB supports 2 pages in this mode.
  1114.  
  1115.     Example:
  1116.        CALL GetCRT(crt)
  1117.        IF crt = 3 THEN
  1118.            CALL Super13
  1119.            ELSE
  1120.            PRINT "Mode Super13 not available"
  1121.        END IF
  1122.           .
  1123.           .
  1124.           .
  1125.        REM  all done with graphics, go back to text mode
  1126.        CALL ModeColor               ' 80 x 25 text mode
  1127.        CALL XModeClear              ' clear QLIB's internal flags
  1128.  
  1129.  
  1130.  
  1131.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1132.  
  1133.     Subroutine: Super13a
  1134.     object file: super13a.obj (q$graph.obj)
  1135.  
  1136.     Requires VGA
  1137.  
  1138.          As with Super13 above, Super13a is an undocumented 256-color
  1139.     mode which I have used on PS/2 computers, and also has been used with
  1140.     Paradise VGA cards.  Super13a provides 360 x 480 resolution, 270% more
  1141.     pixels than the standard SCREEN 13.  This mode does not allow multiple
  1142.     pages.  See Super13 for example.  Super13a is based on John Bridges'
  1143.     mode set code and parameters.
  1144.  
  1145.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1146.  
  1147.     Subroutine: Use32k
  1148.     Subroutine: Use64k
  1149.     object file: q$herc.obj
  1150.  
  1151.     Requires Hercules (mono or InColor)
  1152.  
  1153.          Use32k masks the second 32k block of Hercules memory out of the
  1154.     memory map.  If the second 32k is included in the memory map, QLIB's
  1155.     video routines can use all Hercules screen pages.  The second 32k of
  1156.     Hercules video memory conflicts with most color monitors' address space,
  1157.     so Use32k should be used to mask the second 32k out of the memory map
  1158.     for two-monitor systems.  Use64k allows the second block.  QLIB's
  1159.     default is Use32k.   You MUST call Use64k if you want to use graphics
  1160.     page 1 with Hercules systems.
  1161.  
  1162.     Example:
  1163.          CALL GetCRT(crt%)
  1164.          IF crt% >= 128 THEN CALL Use64k
  1165.  
  1166.  
  1167.  
  1168.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1169.  
  1170.     Subroutine: UseFont (fseg%, fptr%, points%, bytes%)
  1171.     object files: usefont.obj, f8x14.obj
  1172.  
  1173.     Supports: all graphics modes with ymax% > 200
  1174.  
  1175.     UseFont permits use of non-standard fonts with GPrint, GPrintX, GCenter
  1176.     and GCenterX.  The font you wish to use must be somewhere in memory,
  1177.     either "hardwired" into your program or loaded from a disk file.
  1178.  
  1179.     Parameters used when calling UseFont are:
  1180.  
  1181.     fseg% = segment address of character definition data
  1182.     fptr% = offset address of character definition data
  1183.     points% = height of each character on screen (in pixel rows)
  1184.     bytes% = byte interval from the start of one character definition
  1185.              to the next
  1186.  
  1187.     QLIB's GPrint subroutines assume that each character is 8 pixels wide.
  1188.  
  1189.     Example:
  1190.       REM $INCLUDE: 'C:\QB4\QLIB.BI'
  1191.       REM   I want to use the italic font supplied by Hercules with the
  1192.       REM   InColor Card and Graphics Card Plus.  All Hercules font files
  1193.       REM   have a byte interval of 16, even for those fonts which are
  1194.       REM   less than 16 points high.
  1195.  
  1196.       filename$ = "C:\RAMFONT\ITALICS.FNT" + CHR$(0)
  1197.       fseg% = FLoad (filename$)       ' load font file into far memory
  1198.       fptr% = 0                       ' Hercules font definitions begin
  1199.                                       ' at the start of the file
  1200.       points% = 14: bytes% = 16       ' 14-point font
  1201.  
  1202.       CALL UseFont (fseg%, fptr%, points%, bytes%)
  1203.                                       ' GPrint will now use italics font
  1204.                                       ' until SmallText or StdText is
  1205.                                       ' is called, or until UseFont is
  1206.                                       ' called with another font definition     
  1207.  
  1208.   
  1209.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1210.  
  1211.     Subroutine: UseHerc
  1212.     Subroutine: UseDefault
  1213.     object file: useherc.obj ($graph.obj)
  1214.  
  1215.       UseHerc forces QLIB's graphics subroutines to use Hercules-
  1216.     mode algorithms.  This is handy when you want to create a virtual
  1217.     graphics screen (for ScreenDump, as an example) while the computer
  1218.     is displaying a graph in another graphics mode.  UseDefault causes
  1219.     QLIB to use the algorithms for the system's active graphics mode.
  1220.     UseHerc is NOT required if the system is in Hercules mode.
  1221.  
  1222.     Example:
  1223.       CALL UseHerc
  1224.           .
  1225.           .
  1226.           .
  1227.       CALL UseDefault
  1228.  
  1229.  
  1230.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1231.  
  1232.     Subroutine: UseGPage(gpage%, oops%)
  1233.     object files: gpage.obj (q$graph.obj, q$herc.obj, egainfo.obj)
  1234.  
  1235.     Modes supported: HGraph (mono and InColor)    pages 0 and 1
  1236.                      SCREEN 3         pages 0 and 1
  1237.                      SCREEN 7         pages 0 through 7  (with 265k EGA)
  1238.                      SCREEN 8         pages 0 through 3  (with 265k EGA)
  1239.                      SCREEN 9         pages 0 and 1      (256k EGA memory)
  1240.                      SCREEN 10        pages 0 and 1      (256k EGA memory)
  1241.                      Super13          pages 0 and 1
  1242.  
  1243.          UseGPage changes the default screen page for QLIB's graphics
  1244.     subroutines.  QLIB's default gpage% is 0.  If multiple pages are not
  1245.     available for the current mode, or gpage% is too big, oops% = -1.
  1246.  
  1247.     Example:
  1248.          CALL HGraph              ' establish Hercules graphics mode
  1249.                                   ' HGraph calls Use64k
  1250.          gpage% = 1
  1251.          CALL UseGPage(gpage%, oops%)
  1252.                                   ' QLIB's graphics subroutines use page 1 now
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1258.  
  1259.     Subroutine: XMode16(m%, maxX%, maxY%)
  1260.     Subroutine: XMode16A(m0%, m1%, maxX%, maxY%)
  1261.     object file: xmode.obj
  1262.  
  1263.     Subroutine: XModeClear
  1264.     Subroutine: ModeColor
  1265.  
  1266.        XMode16 subroutines allow the use of many extended EGA and VGA
  1267.     graphics cards at higher resolutions than IBM's products allow, in
  1268.     16-color modes.  Depending on the graphics card/monitor combination
  1269.     in use, resolutions up to 800 pixels horizontal and 600 pixels vertical
  1270.     are possible.  The manual supplied with your extended EGA or VGA card
  1271.     contains the information you need to put the high-resolution modes to
  1272.     work.  A multi-frequency monitor is generally required (see the graphics
  1273.     card manual for specific requirements).
  1274.  
  1275.     You must have the required equipment and use the correct mode number;
  1276.     hardware damage may result from improper use of XMode16.  I cannot be
  1277.     held responsible for damage resulting from use of XMode16.
  1278.  
  1279.     When using XMode16, the parameters required are:
  1280.  
  1281.      m% = mode number (from graphics card manual, for 8086 register AL)
  1282.      maxX% = maximum horizontal dimension
  1283.      maxY% = maximum vertical dimension
  1284.  
  1285.     If 800 horizontal pixels are available, maxX% should be 799.  Similarly,
  1286.     if 600 vertical pixels are possible, maxY% should be 599.
  1287.  
  1288.     If your graphics card requires two mode parameters in the 8086's
  1289.     AL and BL registers, use XMode16A instead, where
  1290.  
  1291.      m0% = mode number for AL register
  1292.      m1% = mode number for BL register
  1293.      maxX% = maximum horizontal dimension
  1294.      maxY% = maximum vertical dimension
  1295.  
  1296.     Any QLIB subroutines compatible with XMode16 will work equally well
  1297.     with XMode16A.
  1298.  
  1299.     Your graphics card manual lists mode numbers, equipment requirements,
  1300.     and the number of horizontal and vertical pixels corresponding to the
  1301.     mode.  Mode numbers are usually in hex format.  Some modes and
  1302.     corresponding mode numbers are listed on the next page:
  1303.  
  1304.  
  1305.  
  1306.     Equipment            mode     mode number   Example
  1307.  
  1308.     Orchid ProDesigner   800x600     &H29       CALL XMode16(&H29, 799%, 599%)
  1309.     STB EM/16
  1310.     Genoa
  1311.     Sigma X16
  1312.  
  1313.  
  1314.     Everex MED EGA       640X480     &H70, &H00
  1315.     (Micro Enhancer Deluxe)                CALL XMode16a(&H70, &H00, 639%, 479%)
  1316.                          752x410     &H70, &H01
  1317.                                            CALL XMode16a(&H70, &H01, 751%, 409%)
  1318.  
  1319.  
  1320.     ATI VGA Wonder       800x600     &H54       CALL XMode16(&H54, 799%, 599%)
  1321.  
  1322.  
  1323.     ATI VIP              800x560     &H53       CALL XMode16(&H53, 799%, 559%)
  1324.  
  1325.  
  1326.     Paradise Plus-16     800x600     &H58       CALL XMode16(&H58, 799%, 599%)
  1327.     Paradise Professional
  1328.  
  1329.     Video 7 Fastwrite    800x600     &H62       CALL XMode16(&H62, 799%, 599%)
  1330.     Video 7 VRAM
  1331.  
  1332.     If any of this information conflicts with the specifications in your
  1333.     video card's instruction manual, the manual's recommendation is a safer
  1334.     bet.  Note that all the above modes require a multi-frequency monitor.
  1335.  
  1336.     When you're all done with Graphics mode, CALL ModeColor to return to
  1337.     80x25 text mode, and CALL XModeClear to reset QLIB's internal XMode flags.
  1338.  
  1339.  
  1340.      REM  All done with graphics for now, go back to 80 x 25 text mode
  1341.      CALL ModeColor
  1342.      REM  also clear QLIB's internal flags
  1343.      CALL XModeClear
  1344.  
  1345.   ***************** QWINDOW USER-DEFINED COORDINATE SUBSYSTEM ****************
  1346.  
  1347.  
  1348.   The QLIB QWindow user-defined coordinate subsystem for QLIB graphics is
  1349.   intended as a replacement for BASIC's WINDOW command.  The QWindow system
  1350.   permits the programmer to specify custom coordinates for any QLIB graphics
  1351.   mode, and changes the direction of increasing y-coordinates from the
  1352.   default top-to-bottom to the more familiar bottom-to-top orientation.
  1353.  
  1354.   QWindow subroutines are listed at the end of this file.
  1355.  
  1356.   For each QWindow graphics subroutine, the usage and calling parameters are
  1357.   identical to the primary QLIB graphics subroutine.  For example,
  1358.   to use QWBitBlockBytes, see the documentation for BitBlockBytes, but
  1359.   call QWBitBlockBytes with QWindow coordinates.
  1360.  
  1361.   If you have defined your own coordinates, you may still use QLIB's primary
  1362.   graphics subroutines with the absolute coordinates at the beginning of
  1363.   this file.  If your program repeatedly calls QLIB graphics subroutines
  1364.   with the same coordinates, your program will run a bit faster if you
  1365.   convert QWindow coordinates to QLIB's native absolute coordinates and
  1366.   use the non-QWindow subroutine.  See QW2Abs.
  1367.  
  1368.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1369.  
  1370.     Subroutine: QW2Abs(x, y)
  1371.     object file: qw2abs.obj, qwindow.obj
  1372.  
  1373.         QW2Abs converts QWindow coordinates to QLIB's native absolute
  1374.     coordinates.  This is handy if you will be repeatedly calling QLIB
  1375.     graphics subroutines with the same coordinates; convertng to absolute
  1376.     coordinates and calling the non-QWindow subroutine will make your
  1377.     program run a bit faster.
  1378.  
  1379.  
  1380.    
  1381.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1382.  
  1383.     Subroutine: QWindow(x0, y0, x1, y1)
  1384.     object file: qwindow.obj
  1385.  
  1386.         QWindow establishes the user-defined coordinate system.  The
  1387.     coordinate at (x0, y0) is the lower left corner of the working area
  1388.     and the coordinate at (x1, y1) is the upper right corner of the area.
  1389.     The working area can be either the entire screen or QLIB's active view
  1390.     area (see QWScreen and QWView).  If x0 is less than 0, the origin
  1391.     of the horizontal axis will be shifted right.  If y0 is less than 0,
  1392.     the origin of the vertical axis will be shifted up.
  1393.     
  1394.  
  1395.     Example:
  1396.        DEFINT A-Z
  1397.        REM  my data series has a minimum y-value of -32 and a maximum
  1398.        REM  y-value of 181, while the x-values range from -10 to 75
  1399.  
  1400.        CALL ScreenMode(&H10)                ' EGA 640x350 mode
  1401.        CALL QWScreen                        ' coordinates relative
  1402.                                             ' to entire screen
  1403.        CALL QWindow(-10, -32, 75, 181)      ' user-defined graph coordinates
  1404.        CALL QWLine(0, -32, 0, 181, 1)       ' draw vertical axis
  1405.        CALL QWLine(-10, 0, 75, 0,  1)       ' draw horizontal axis
  1406.  
  1407.        REM put dots on the screen for a X vs. Y chart
  1408.        FOR i = 0 to 100
  1409.            CALL QWSetPixel(x%(i), y%(i), style%)
  1410.        NEXT i
  1411.  
  1412.  
  1413.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1414.  
  1415.     Subroutine: QWScreen
  1416.     Subroutine: QWView
  1417.     object file: qwindow.obj
  1418.  
  1419.        These subroutines allow you to define your coordinate system
  1420.     relative to the entire screen (QWScreen) or relative to QLIB's active
  1421.     View area.
  1422.  
  1423.     Example:
  1424.        DEFINT A-Z
  1425.        REM  I want to use 90% of the screen dimensions for a plot with
  1426.        REM  coordinates from -100 to +100
  1427.  
  1428.        REM  start with View equal to entire screen area
  1429.        CALL ResetView
  1430.  
  1431.        REM  next, define the coordinate system, relative to entire screen
  1432.        CALL QWindow(-100, -100, 100, 100)
  1433.        CALL QWScreen
  1434.  
  1435.        REM  now get the absolute coordinates for 90% of the screen dimensions
  1436.        x0% = -90: y0% = -90
  1437.        x1% = 90: y0% = 90
  1438.        CALL QW2Abs(x0%, y0%)       ' convert first coordinate
  1439.        CALL QW2Abs(x1%, y1%)       ' convert second coordinate
  1440.  
  1441.        REM  use absolute coordinates to set QLIB view area
  1442.        CALL SetView(x0%, y0%, x1%, y1%)
  1443.  
  1444.        REM  make QWindow coordinates relative to active view area
  1445.        CALL QWView
  1446.  
  1447.        REM  ready to go!
  1448.  
  1449.  
  1450.  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  1451.  
  1452.     QWindow subroutines, the comparable QLIB subroutine and QWindow
  1453.     object files are listed below:
  1454.  
  1455.     QWindow subroutine   QLIB subroutine      object file
  1456.  
  1457.     QWLine               DrawLine             qwline.obj
  1458.     QWBox                DrawBox              qwline.obj
  1459.     QWFillBox            FillBox              qwline.obj
  1460.     QWFill               FillArea             qwfill.obj
  1461.     QWGCenter            GCenter              qwcenter.obj
  1462.     QWGCenterX           GCenterX             qwcentrx.obj
  1463.     QWCircle             DrawCircle           qwcircle.obj
  1464.     QWGLineEdit          GLineEdit            qwgedit.obj
  1465.     QWGPrint             GPrint               qwgprint.obj
  1466.     QWGPrintUP           GPrintUP             qwgprint.obj
  1467.     QWGPrintDOWN         GPrintDOWN           qwgprint.obj
  1468.     QWBitBlockBytes      BitBlockBytes        qwblock.obj
  1469.     QWBitBlockSave       BitBlockSave         qwblock.obj
  1470.     QWBitBlockRestore    BitBlockRestore      qwblock.obj
  1471.     QWBitPlaneBytes      BitPlaneBytes        qwplane.obj
  1472.     QWBitPlaneSave       BitPlaneSave         qwplane.obj
  1473.     QWBitPlaneRestore    BitPlaneRestore      qwplane.obj
  1474.     QWGetPixel           GetPixel             qwpixel.obj
  1475.     QWSetPixel           SetPixel             qwpixel.obj
  1476.     QWGPrintX            GPrintX              qwprintx.obj
  1477.     QWGPrint2X           GPrint2X             qwprintx.obj
  1478.     QWGPrintUPX          GPrintUPX            qwprintx.obj
  1479.     QWGPrintDOWNX        GPrintDOWNX          qwprintx.obj
  1480.     QWGPrintUP2X         GPrintUP2X           qwprintx.obj
  1481.     QWGPrintDOWN2X       GPrintDOWN2X         qwprintx.obj
  1482.     QWGCursor            GCursor              qwcursor.obj
  1483.     QWGUCursor           GUCursor             qwcursor.obj
  1484.  
  1485.     In all cases, QWindow subroutines are called from your BASIC program
  1486.     with the same parameters, except that screen coordinates are QWindow
  1487.     coordinates instead of QLIB's native absolute pixel locations.
  1488.  
  1489.  
  1490.